{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Deterministic Policy Gradient (DDPG) with TensorFlow\n",
    "\n",
    "In this notebook we will look at Deep Deterministic Policy Gradient (DDPG) algorithm using TensorFlow. DDPG is a variation of Q-Learning with continuous action functions. When we have discrete functions, we learn Q-function of a  given state and all possible actions. We then pick the best action and Q-value using `max` over all values: Q(s,a), a is all possible actions. \n",
    "\n",
    "$$a^*(s) = arg \\underset{a}{max} Q^*(s,a)$$ \n",
    "\n",
    "However, when action is continuous, we cannot find the max so easily. It becomes an optimization problem with significant costs as we have to find the max at every step.\n",
    "\n",
    "in DDPG we learn two networks, one is a policy network which takes state as input and learns to output the policy/action. Another network learns the Q function. However, unlike Q-learning of past, it takes state and actions as inputs and produces Q-value as output. \n",
    "\n",
    "DDPG is an off-policy learning like Q-Learning, so we use ReplayBuffer to collect the transitions and iterate over it a batch to do gradient update for the policy(Actor) and Q-value(Critic) networks. \n",
    "\n",
    "Like Q-Learning, we also use target networks, both for policy as well as Q-value. The target networks are updated using polyak averaging. \n",
    "\n",
    "\n",
    "Click here to access the paper which proposed DDPG: https://arxiv.org/pdf/1509.02971.pdf\n",
    "\n",
    "The complete Algorithm is as given below:\n",
    "\n",
    "***\n",
    "**Deep Deterministic Policy Gradient**\n",
    "***\n",
    " \n",
    "1. Input initial policy parameters $\\theta$,  Q-function parameters $\\phi$, empty replay buffer D\n",
    "\n",
    "2. Set target parameters equal to online parameters $\\theta_{targ} \\leftarrow \\theta$ and $\\phi_{targ} \\leftarrow \\phi$\n",
    "\n",
    "3. **repeat**\n",
    "\n",
    "4. Observe state s and select action $a = clip(\\mu_\\theta(s)+\\epsilon, a_{Low}, a_{High}), \\text{where  } \\epsilon \\sim N$\n",
    "\n",
    "5. Execute a in environment and observe next state s', reward r, and done signal d\n",
    "\n",
    "6. Store `(s,a,r,s',d)` in Replay Buffer D\n",
    "\n",
    "7. if `s'` is terminal state, reset the environment\n",
    "\n",
    "8. if it's time to update **then**:\n",
    "\n",
    "9. &emsp;&emsp;for as many updates as required:\n",
    "\n",
    "10. &emsp;&emsp;&emsp;&emsp;Sample a batch B={`(s,a,r,s',d)`} from replay Buffer D:\n",
    "\n",
    "11. &emsp;&emsp;&emsp;&emsp;Compute targets: $$y(r,s',d) = r + \\gamma(1-d)Q_{targ}(s',\\mu_{\\theta_{targ}}(s'))$$\n",
    "\n",
    "12. &emsp;&emsp;&emsp;&emsp;Update Q function with one step gradient descent on $\\phi$: $$\\nabla_\\phi \\frac{1}{|B|} \\sum_{(s,a,r,s',d)\\in B}(Q_\\phi(s,a) - y(r,s',d))^2$$\n",
    "\n",
    "13. &emsp;&emsp;&emsp;&emsp;Update Policy with one step gradient Ascent on $\\theta$: $$\\nabla_\\theta \\frac{1}{|B|} \\sum_{s \\in B} Q_\\phi(s, \\mu_\\phi(s, \\mu_\\theta(s))$$\n",
    "\n",
    "14. Update target networks using polyak averaging: $$\\phi_{targ} \\leftarrow \\rho\\phi_{targ} + (1-\\rho)\\phi$$  $$\\theta_{targ} \\leftarrow \\rho\\theta_{targ} + (1-\\rho)\\theta$$\n",
    "***\n",
    "\n",
    "\n",
    "#### Key Features of DDPG\n",
    "1. DDPG is an off-policy algorithm.\n",
    "2. DDPG can only be used for environments with continuous action spaces.\n",
    "3. DDPG can be thought of as being deep Q-learning for continuous action spaces.\n",
    "\n",
    "\n",
    "#### Our Implementation\n",
    "This notebook follows the code found in OpenAI's [Spinning Up Library](https://spinningup.openai.com/en/latest/algorithms/ddpg.html). In this notebook we have broken the code into separate code cells with required explanations. Also some of the implementations like ReplayBuffer have been borrowed from our past notebooks to provide continuity. Further some codes like building of networks have been simplified resulting in easier to understand but more verbose code. \n",
    "\n",
    "The tensorflow version implemented in this notebook uses eager evaluation under TF2 vs TF1 implementations in SPinning up Library. The code in this notebook mirrors the pytorch version and may look different from the spinning up implementations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.signal\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers \n",
    "from tensorflow.keras import Model, Input\n",
    "\n",
    "from copy import deepcopy\n",
    "import gym\n",
    "\n",
    "\n",
    "import os\n",
    "import io\n",
    "import base64\n",
    "import time\n",
    "import glob\n",
    "from IPython.display import HTML\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - Pendulum\n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are continuous. We will build it on `Pendulum-v0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name, seed=None):\n",
    "    # remove time limit wrapper from environment\n",
    "    env = gym.make(env_name).unwrapped\n",
    "    if seed is not None:\n",
    "        env.seed(seed)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State shape: (3,)\n",
      "Action shape: (1,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'Pendulum-v0'\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset()\n",
    "plt.imshow(env.render(\"rgb_array\"))\n",
    "state_shape, action_shape = env.observation_space.shape, env.action_space.shape\n",
    "print('State shape: {}'.format(state_shape))\n",
    "print('Action shape: {}'.format(action_shape))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Policy network (Actor)\n",
    "It is a simple 2 hidden layer network which takes state as input and produces action making sure that action values are within the allowed range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPActor(tf.keras.Model):\n",
    "    def __init__(self, state_dim, act_dim, act_limit):\n",
    "        super().__init__()\n",
    "        self.act_limit = act_limit\n",
    "        self.fc1 = layers.Dense(256, activation=\"relu\")\n",
    "        self.fc2 = layers.Dense(256, activation=\"relu\")\n",
    "        self.actor = layers.Dense(act_dim)\n",
    "    \n",
    "    def call(self, s):\n",
    "        x = self.fc1(s)\n",
    "        x = self.fc2(x)\n",
    "        x = self.actor(x)\n",
    "        x = tf.keras.activations.tanh(x)  # to output in range(-1,1)\n",
    "        x = self.act_limit * x\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Q-network network (Critic)\n",
    "It is a simple 2 hidden layer network which takes state and action as input and produces Q-value as output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPQFunction(tf.keras.Model):\n",
    "    def __init__(self, state_dim, act_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = layers.Dense(256, activation=\"relu\")\n",
    "        self.fc2 = layers.Dense(256, activation=\"relu\")\n",
    "        self.Q = layers.Dense(1)\n",
    "    \n",
    "    def call(self, s, a):\n",
    "        x = tf.concat([s,a], axis=-1)\n",
    "        x = self.fc1(x)\n",
    "        x = self.fc2(x)\n",
    "        q = self.Q(x)\n",
    "        return tf.squeeze(q, -1)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combine Actor and Critic into a single model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPActorCritic(tf.keras.Model):\n",
    "    def __init__(self, observation_space, action_space):\n",
    "        super().__init__()\n",
    "        self.state_dim = observation_space.shape[0]\n",
    "        self.act_dim = action_space.shape[0]\n",
    "        self.act_limit = action_space.high[0]\n",
    "        \n",
    "        #build Q and policy functions\n",
    "        self.q = MLPQFunction(self.state_dim, self.act_dim)\n",
    "        self.policy = MLPActor(self.state_dim, self.act_dim, self.act_limit)\n",
    "        \n",
    "    def act(self, state):\n",
    "        return self.policy(state).numpy()\n",
    "\n",
    "    def get_action(self, s, noise_scale):\n",
    "        a = self.act(s.reshape(1,-1).astype(\"float32\")).reshape(-1)\n",
    "        a += noise_scale * np.random.randn(self.act_dim)\n",
    "        return np.clip(a, -self.act_limit, self.act_limit)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon-greedy$) to sample from the environment and store the transitions (s,a,r,s',done) into a buffer. These samples are used multiple times in a learning making the process sample efficient. \n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size=1e6):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "            self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size=32):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q-loss\n",
    "\n",
    "Compute Q-loss as per equation:\n",
    "    \n",
    "$$y(r,s',d) = r + \\gamma(1-d)Q_{targ}(s',\\mu_{\\theta_{targ}}(s'))$$\n",
    "\n",
    "$$Q_{Loss} =  \\frac{1}{|B|} \\sum_{(s,a,r,s',d)\\in B}(Q_\\phi(s,a) - y(r,s',d))^2$$\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def compute_q_loss(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma, tape):\n",
    "    \n",
    "    # convert numpy array to proper data types\n",
    "    states = states.astype('float32')\n",
    "    actions = actions.astype('float32')\n",
    "    rewards = rewards.astype('float32')\n",
    "    next_states = next_states.astype('float32')\n",
    "    done_flags = done_flags.astype('float32')\n",
    "    \n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    predicted_qvalues = agent.q(states, actions)\n",
    "    \n",
    "    # Bellman backup for Q function\n",
    "    with tape.stop_recording():\n",
    "        q__next_state_values = target_network.q(next_states, target_network.policy(next_states))\n",
    "        target = rewards + gamma * (1 - done_flags) * q__next_state_values\n",
    "\n",
    "    # MSE loss against Bellman backup\n",
    "    loss_q = tf.reduce_mean((predicted_qvalues - target)**2)\n",
    "\n",
    "    return loss_q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Policy-Loss\n",
    "\n",
    "Compute Policy Loss as per equation:\n",
    "    \n",
    "$$ Policy_{Loss} = - \\frac{1}{|B|} \\sum_{s \\in B} Q_\\phi(s, \\mu_\\phi(s, \\mu_\\theta(s))$$\n",
    "\n",
    "Please note the `-` sign. We need to do gradient ascent but TensorFlow does gradient descent. We convert the ascent to descent using a -ve sign. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_policy_loss(agent, states, tape):\n",
    "    \n",
    "    # convert numpy array to proper data type\n",
    "    states = states.astype('float32')\n",
    "    \n",
    "    predicted_qvalues = agent.q(states, agent.policy(states))\n",
    "    \n",
    "    loss_policy = - tf.reduce_mean(predicted_qvalues)\n",
    "    \n",
    "    return loss_policy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### One step gradient Descent on both Policy(Actor) and Q-value(Critic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_step_update(agent, target_network, q_optimizer, policy_optimizer, \n",
    "                    states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, polyak=0.995):\n",
    "    \n",
    "    #one step gradient for q-values\n",
    "    with tf.GradientTape() as tape:\n",
    "        loss_q = compute_q_loss(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma, tape)\n",
    "\n",
    "        gradients = tape.gradient(loss_q, agent.q.trainable_variables)\n",
    "        q_optimizer.apply_gradients(zip(gradients, agent.q.trainable_variables))\n",
    "\n",
    "    #Freeze Q-network\n",
    "    agent.q.trainable=False \n",
    "    \n",
    "    #one setep gradient for policy network\n",
    "    with tf.GradientTape() as tape:\n",
    "        loss_policy = compute_policy_loss(agent, states, tape)\n",
    "        gradients = tape.gradient(loss_policy, agent.policy.trainable_variables)\n",
    "        policy_optimizer.apply_gradients(zip(gradients, agent.policy.trainable_variables))\n",
    "\n",
    "    #UnFreeze Q-network\n",
    "    agent.q.trainable=True \n",
    "    \n",
    "    # update target networks with polyak averaging\n",
    "    updated_model_weights = []\n",
    "    for weights, weights_target in zip(agent.get_weights(), target_network.get_weights()):\n",
    "        new_weights = polyak*weights_target+(1-polyak)*weights\n",
    "        updated_model_weights.append(new_weights)\n",
    "    target_network.set_weights(updated_model_weights)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### To Test performance of agent without any noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_agent(env, agent, num_test_episodes, max_ep_len):\n",
    "    ep_rets, ep_lens = [], []\n",
    "    for j in range(num_test_episodes):\n",
    "        state, done, ep_ret, ep_len = env.reset(), False, 0, 0\n",
    "        while not(done or (ep_len == max_ep_len)):\n",
    "            # Take deterministic actions at test time (noise_scale=0)\n",
    "            state, reward, done, _ = env.step(agent.get_action(state, 0))\n",
    "            ep_ret += reward\n",
    "            ep_len += 1\n",
    "        ep_rets.append(ep_ret)\n",
    "        ep_lens.append(ep_len)\n",
    "    return np.mean(ep_rets), np.mean(ep_lens)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DDPG Algorithm\n",
    "\n",
    "We pull all the pieces together to train the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ddpg(env_fn, seed=0, \n",
    "         steps_per_epoch=4000, epochs=5, replay_size=int(1e6), gamma=0.99, \n",
    "         polyak=0.995, policy_lr=1e-3, q_lr=1e-3, batch_size=100, start_steps=10000, \n",
    "         update_after=1000, update_every=50, act_noise=0.1, num_test_episodes=10, \n",
    "         max_ep_len=1000):\n",
    "    \n",
    "    tf.random.set_seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    \n",
    "    env, test_env = env_fn(), env_fn()\n",
    "    \n",
    "    ep_rets, ep_lens = [], []\n",
    "\n",
    "    state_dim = env.observation_space.shape\n",
    "    act_dim = env.action_space.shape[0]\n",
    "    \n",
    "    act_limit = env.action_space.high[0]\n",
    "    \n",
    "    agent = MLPActorCritic(env.observation_space, env.action_space)\n",
    "    \n",
    "    # force a build of model to initialize the model parameters\n",
    "    s = env.reset()\n",
    "    a = env.action_space.sample()    \n",
    "    agent.policy(np.array([s], dtype=np.float32))\n",
    "    agent.q(np.array([s],dtype=np.float32),np.array([a],dtype=np.float32))\n",
    "\n",
    "    # copy target network\n",
    "    target_network = deepcopy(agent)\n",
    "    \n",
    "    \n",
    "    # Freeze target networks with respect to optimizers (only update via polyak averaging)\n",
    "    target_network.policy.trainable=False\n",
    "    target_network.q.trainable = False\n",
    "    \n",
    "    # Experience buffer\n",
    "    replay_buffer = ReplayBuffer(replay_size)\n",
    "    \n",
    "    #optimizers\n",
    "    q_optimizer = tf.keras.optimizers.Adam(learning_rate=q_lr)\n",
    "    policy_optimizer = tf.keras.optimizers.Adam(learning_rate=policy_lr)\n",
    "    \n",
    "    total_steps = steps_per_epoch*epochs\n",
    "    state, ep_ret, ep_len = env.reset(), 0, 0\n",
    "    \n",
    "    for t in range(total_steps):\n",
    "        if t > start_steps:\n",
    "            action = agent.get_action(state, act_noise)\n",
    "        else:\n",
    "            action = env.action_space.sample()\n",
    "            \n",
    "        next_state, reward, done, _ = env.step(action)\n",
    "        ep_ret += reward\n",
    "        ep_len += 1\n",
    "        \n",
    "        # Ignore the \"done\" signal if it comes from hitting the time\n",
    "        # horizon (that is, when it's an artificial terminal signal\n",
    "        # that isn't based on the agent's state)\n",
    "        done = False if ep_len==max_ep_len else done\n",
    "        \n",
    "        # Store experience to replay buffer\n",
    "        replay_buffer.add(state, action, reward, next_state, done)\n",
    "        \n",
    "        state = next_state\n",
    "        \n",
    "        # End of trajectory handling\n",
    "        if done or (ep_len == max_ep_len):\n",
    "            ep_rets.append(ep_ret)\n",
    "            ep_lens.append(ep_len)\n",
    "            state, ep_ret, ep_len = env.reset(), 0, 0\n",
    "        \n",
    "        # Update handling\n",
    "        if t >= update_after and t % update_every == 0:\n",
    "            for _ in range(update_every):\n",
    "                states, actions, rewards, next_states, done_flags = replay_buffer.sample(batch_size)\n",
    "                \n",
    "                one_step_update(\n",
    "                        agent, target_network, q_optimizer, policy_optimizer, \n",
    "                        states, actions, rewards, next_states, done_flags,\n",
    "                        gamma, polyak\n",
    "                )\n",
    "        \n",
    "        # End of epoch handling\n",
    "        if (t+1) % steps_per_epoch == 0:\n",
    "            epoch = (t+1) // steps_per_epoch\n",
    "            \n",
    "            avg_ret, avg_len = test_agent(test_env, agent, num_test_episodes, max_ep_len)\n",
    "            print(\"End of epoch: {:.0f}, Training Average Reward: {:.0f}, Training Average Length: {:.0f}\".format(epoch, np.mean(ep_rets), np.mean(ep_lens)))\n",
    "            print(\"End of epoch: {:.0f}, Test Average Reward: {:.0f}, Test Average Length: {:.0f}\".format(epoch, avg_ret, avg_len))\n",
    "            ep_rets, ep_lens = [], []\n",
    "    \n",
    "    return agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of epoch: 1, Training Average Reward: -5794, Training Average Length: 1000\n",
      "End of epoch: 1, Test Average Reward: -205, Test Average Length: 1000\n",
      "End of epoch: 2, Training Average Reward: -5762, Training Average Length: 1000\n",
      "End of epoch: 2, Test Average Reward: -122, Test Average Length: 1000\n",
      "End of epoch: 3, Training Average Reward: -3138, Training Average Length: 1000\n",
      "End of epoch: 3, Test Average Reward: -148, Test Average Length: 1000\n",
      "End of epoch: 4, Training Average Reward: -205, Training Average Length: 1000\n",
      "End of epoch: 4, Test Average Reward: -146, Test Average Length: 1000\n",
      "End of epoch: 5, Training Average Reward: -167, Training Average Length: 1000\n",
      "End of epoch: 5, Test Average Reward: -147, Test Average Length: 1000\n"
     ]
    }
   ],
   "source": [
    "env_name = 'Pendulum-v0'\n",
    "agent = ddpg(lambda : make_env(env_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_animation(env, agent, save_dir):\n",
    "    \n",
    "    try:\n",
    "        env = gym.wrappers.Monitor(\n",
    "            env, save_dir, video_callable=lambda id: True, force=True, mode='evaluation')\n",
    "    except gym.error.Error as e:\n",
    "        print(e)\n",
    "\n",
    "    if not os.path.exists(save_dir):\n",
    "        os.makedirs(save_dir)\n",
    "        \n",
    "    state, done, ep_ret, ep_len = env.reset(), False, 0, 0\n",
    "    while not done:\n",
    "        # Take deterministic actions at test time (noise_scale=0)\n",
    "        state, reward, done, _ = env.step(agent.get_action(state, 0))\n",
    "        ep_ret += reward\n",
    "        ep_len += 1\n",
    "\n",
    "    print('Reward: {}'.format(ep_ret))\n",
    "    env.close()\n",
    "            \n",
    "def display_animation(filepath):\n",
    "    video = io.open(filepath, 'r+b').read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    return HTML(data='''<video alt=\"test\" controls>\n",
    "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
    "                 </video>'''.format(encoded.decode('ascii')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reward: -117.70019506607441\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Animate learned policy\n",
    "save_dir='./videos/tensorflow/ddpg/pendulum'\n",
    "env = gym.make(env_name)\n",
    "generate_animation(env, agent, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train and evaluate performance on LunarLander Environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of epoch: 1, Training Average Reward: -203, Training Average Length: 106\n",
      "End of epoch: 1, Test Average Reward: -149, Test Average Length: 231\n",
      "End of epoch: 2, Training Average Reward: -192, Training Average Length: 99\n",
      "End of epoch: 2, Test Average Reward: -63, Test Average Length: 996\n",
      "End of epoch: 3, Training Average Reward: -199, Training Average Length: 139\n",
      "End of epoch: 3, Test Average Reward: -30, Test Average Length: 540\n",
      "End of epoch: 4, Training Average Reward: -60, Training Average Length: 264\n",
      "End of epoch: 4, Test Average Reward: -121, Test Average Length: 126\n",
      "End of epoch: 5, Training Average Reward: -103, Training Average Length: 243\n",
      "End of epoch: 5, Test Average Reward: -114, Test Average Length: 217\n",
      "Reward: -154.04133279740103\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Train\n",
    "env_name = 'LunarLanderContinuous-v2'\n",
    "agent1 = ddpg(lambda : make_env(env_name))\n",
    "\n",
    "# Animate learned policy\n",
    "save_dir='./videos/tensorflow/ddpg/lunar'\n",
    "env = gym.make(env_name)\n",
    "generate_animation(env, agent1, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
